package Fachada;

/**
 * Classe responsável por implementar uma fachada para a GUI.
 * 
 */

import ClassesBasicas.*;
import Negocio.*;
import erro.GeralException;
import erro.NegocioException;
import erro.TerminalException;
import java.util.ArrayList;
import java.util.Collection;


public class Fachada {

    	private NegocioComponente rncomp;
	private NegocioAtividade rnAtividade;
	private NegocioEstadio rnEstadio;
	private NegocioPais rnPais;
	private NegocioCopa rnCopa;
	private NegocioArbitro rnArbitro;
	private NegocioSelecao rnSelecao;
        private NegocioFuncao rnFuncao;
        private NegocioSumulaJogo rnSumulaJogo;
        
	public Fachada() {
		rncomp = new NegocioComponente();
		rnAtividade = new NegocioAtividade();
		rnEstadio = new NegocioEstadio();
		rnPais = new NegocioPais();
		rnCopa = new NegocioCopa();
		rnArbitro = new NegocioArbitro();
		rnSelecao = new NegocioSelecao();
                rnFuncao = new NegocioFuncao();
                rnSumulaJogo = new NegocioSumulaJogo();
        }
		
		
	/*Início das implementações de ESDRAS */
	
	/*Atividade*/
	
	/**
	 * Salva uma atividade
	 * 
	 * @author Esdras
	 * @param  Atividade
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void salvarAtividade(Atividade at) throws NegocioException,GeralException {

		if(!rnAtividade.existeAtividade(at))
			
			rnAtividade.salvar(at);
		
		else
			
			throw new GeralException("Atividade j� existe");
	}
	
	/**
	 * Consulta uma atividade
	 * 
	 * @author Esdras
	 * @param at
	 * @return Atividade
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public Atividade consultarAtividade(Atividade at) throws NegocioException,GeralException{
		
	    if(rnAtividade.existeAtividade(at))
	    	
	    	return rnAtividade.consultar(at.getnome_Atividade());
	    
	    else
	    	
	    	throw new GeralException("Consulta : Atividade n�o existe");
	}
	
	/**
	 * Exclui uma atividade
	 * 
	 * @param at
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void excluirAtividade(Atividade at) throws NegocioException,GeralException{
		
		if(rnAtividade.existeAtividade(at))
			
			rnAtividade.excluir(at.getnome_Atividade());
		
		else
			
			throw new GeralException("Atividade n�o existe");
	}

	/**
	 * Lista todas as Atividades
	 * @author Esdras
	 * @return ArrayList<Atividade>
	 * @throws NegocioException
	 */
	public ArrayList<Atividade> listarAtividade() throws NegocioException{
		return rnAtividade.listarAtividade();
	}
	/*Atividade*/
	
	/*COMPONENTE*/
	/**
	 * Salva um componente
	 * 
	 * @author Esdras
	 * @param Componente
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void salvarComponente(Componente comp)throws NegocioException,GeralException{
		
		if(!rncomp.existComp(comp))
			rncomp.salvar(comp);
		else
			throw new GeralException("Componente j� exixte");
	}
	/**
	 * Exclui um componente
	 * 
	 * @param Componente
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void excluirComponnte(Componente comp)throws NegocioException, GeralException{
		if(rncomp.existComp(comp))
			rncomp.excluir(comp.getNomeComponente());
		else
			throw new GeralException("Componente n�o existe");
		
	}
	/**
	 * Consulta um componente
	 * 
	 * @author Esdras
	 * @param comp
	 * @return
	 * @throws GeralException
	 * @throws NegocioException
	 */
	public Componente consultaComponente(Componente comp)throws GeralException,NegocioException{
		if(rncomp.existComp(comp))
			return rncomp.consultar(comp.getNomeComponente());
		else
			throw new GeralException("Consulta : Componente n�o existe");
		
	}
	/**
	 * Lista todos os componentes de uma deterninada seleção;
	 * 
	 * @author Esdras
	 * @param nome
	 * @return
	 * @throws NegocioException
	 */
	public Collection<Componente> listarComponentePorCel(String nome) throws NegocioException{
		return rncomp.listarPorSel(nome);
	} 
	/*Componente*/
	
	/*Seleçao*/
	/**
	 * Salva uma Seleção;
	 * 
	 * @author Esdras
	 * @param  Selecao
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void salvarSelecao(Selecao sel) throws NegocioException,GeralException{
		if(!rnSelecao.existeSelecao(sel)){
			rnSelecao.salvar(sel);
		}else{
			throw new GeralException("Seleção já existe");
		}
	}
	/**
	 * Exclui uma seleção;
	 * 
	 * @author Esdras
	 * @param sel
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public void exvluirSelecao(Selecao sel) throws NegocioException,GeralException{
		if(rnSelecao.existeSelecao(sel)){
			rnSelecao.excluir(sel.getNomeSelecao());
		}else{
			throw new GeralException("Sele��o n�o existe");
		}
	}
	/**
	 * Consulta uma seleção 
	 * 
	 * @author Esdras
	 * @param sel
	 * @return Selecao
	 * @throws NegocioException
	 * @throws GeralException
	 */
	public Selecao consultarSelecao(Selecao sel) throws NegocioException, GeralException{
		if(rnSelecao.existeSelecao(sel)){
			return rnSelecao.consultar(sel.getNomeSelecao());
		}else{
			throw new GeralException("Seleção não existe");
		}
	}
	/**
	 * @author Esdras
	 * @return ArrayList<Selecao>
	 * @throws NegocioException
	 */
	public ArrayList<Selecao> listarSelecao() throws NegocioException{
		return rnSelecao.listarSelecao();
	}
	
	/*Seleçao*/
	
	/*Término das implementações de ESDRAS*/
	
	
	/*Início das implementações de LEYLA */
	/*ESTADIO*/
	
	/**
	 * Salva um Estádio
	 * 
	 * @author Leyla
	 * @param  es
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	
	public void salvarEstadio(Estadio es) throws NegocioException,GeralException {

		if(!rnEstadio.existeEstadio(es))
			rnEstadio.salvar(es);
		else
			throw new GeralException("Estádio já cadastrado!");
	}
	

	/**
	 * Consulta um Estádio
	 * 
	 * @author Leyla
	 * @param es
	 * @return Estadio
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	
	public Estadio consultarEstadio(Estadio es) throws NegocioException,GeralException{
		
	    if(rnEstadio.existeEstadio(es))
	    	return rnEstadio.consultarNome(es.getNomeEstadio());
	    else
	    	throw new GeralException("Estádio não cadastrado!");
	}
        
	public Estadio consultarEstadioCod(int codEstadio) throws NegocioException,GeralException{
		return rnEstadio.consultarCod(codEstadio);
	}
	
        public Estadio consultarEstadioNome(String nomeEstadio) throws NegocioException,GeralException{
		return rnEstadio.consultarNome(nomeEstadio);
	}
        
        /**
         * Altera um Estádio
         * 
         * @param es
         * @throws GeralException
         * @throws TerminalException 
         */
        
        public void alterarEstadio(Estadio es) throws GeralException, TerminalException{
            rnEstadio.alterar(es);
        } 
        
	/**
	 * Exclui um Estádio
	 * 
	 * @author leyla
	 * @param es
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	
	public void excluirEstadio(Estadio es) throws NegocioException,GeralException{
		
		if(rnEstadio.existeEstadio(es))
			rnEstadio.excluirNome(es.getNomeEstadio());
		else
			throw new GeralException("Estádio não cadastrado!");
	}

        public void excluirEstadio(int codEstadio) throws NegocioException,GeralException{
            
            if(rnEstadio.consultarCod(codEstadio) == null)
                throw new GeralException("Estadio não existe");
                    rnEstadio.excluirCod(codEstadio);
	}
        
	/**
	 * Lista todos os Estádios
	 * 
	 * @author leyla
	 * @return ArrayList<Estadio>
	 * @throws NegocioException
	 * 
	 */
	
	public ArrayList<Estadio> listarEstadio() throws NegocioException{
		return rnEstadio.listarEstadio();
	}
        
        /**
	 * Salva uma Função
	 * 
	 * @author Leyla
	 * @param  f
	 * @throws NegocioException
	 * @throws GeralException
	 */
	 
	public void salvarFuncao(Funcao f) throws NegocioException,GeralException {

		if(!rnFuncao.existeFuncao(f))
			rnFuncao.salvar(f);
		else
			throw new GeralException("Funcao ja cadastrada!");
	}
	
	
	/**
	 * Consulta uma Funcao pelo nome
	 * 
	 * @author Leyla
	 * @param f
	 * @return Funcao
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	 
	public Funcao consultarFuncaoNome(String nome) throws NegocioException,GeralException{
            return rnFuncao.consultar(nome);
	}
	
	public Funcao consultarFuncaoId(int codFuncao) throws NegocioException,GeralException{
		return rnFuncao.consultar(codFuncao);
	}
	
	/**
	 * Exclui uma Funcao
	 * 
	 * @param f
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	
	public void excluirFuncao(String funcao) throws NegocioException,GeralException{
		
		if(rnFuncao.consultar(funcao) == null)
                    throw new GeralException("Função não cadastrada!");
			rnFuncao.excluir(funcao);
	}
	
	public void excluirFuncao(int codFuncao) throws NegocioException,GeralException{
            
            if(rnFuncao.consultar(codFuncao) == null)
                throw new GeralException("Função não existe");
                    rnFuncao.excluir(codFuncao);
	}
	
	/**
	 * Lista todos as Funções.
	 * 
	 * @author Leyla
	 * @return ArrayList<Funcao>
	 * @throws NegocioException
	 * 
	 */
	
	public ArrayList<Funcao> listarFuncao() throws NegocioException{
		return rnFuncao.listarFuncao();
	}
		
	/*Término das implementações de LEYLA*/
	
	
	
	/*Início das implementações do componente KLEDSON*/
	/*PAÍS*/
	
	/**
	 * Salva um País
	 * 
	 * @author Kledson
	 * @param  Pais
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	 
	public void salvarPais(Pais p) throws NegocioException,GeralException {

		if(!rnPais.existePais(p))
			
			rnPais.salvar(p);
		else
			throw new GeralException("Pais j� cadastrado!");
	}
	
	
	/**
	 * Consulta um Pais
	 * 
	 * @author Kledson
	 * @param p
	 * @return Pais
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	 
	public Pais consultarPais(String nome) throws NegocioException,GeralException{
    	return rnPais.consultar(nome);
	}
	
	public Pais consultarPais(int id) throws NegocioException,GeralException{
		return rnPais.consultar(id);
	}
	
	/**
	 * Exclui um País
	 * 
	 * @param p
	 * @throws NegocioException
	 * @throws GeralException
	 * 
	 */
	
	public void excluirPais(String pais) throws NegocioException,GeralException{
		
		if(rnPais.consultar(pais) == null)
			throw new GeralException("Pais nao existe");
			rnPais.excluir(pais);
	}
	
	public void excluirPais(int id) throws NegocioException,GeralException{
	
		if(rnPais.consultar(id) == null)
			throw new GeralException("Pais nao existe");
		
		rnPais.excluir(id);
	}
	
	/**
	 * Lista todos os Paises.
	 * 
	 * @author Kledson
	 * @return ArrayList<Pais>
	 * @throws NegocioException
	 * 
	 */
	
	public ArrayList<Pais> listarPais() throws NegocioException{
		return rnPais.listarPais();
	}

/*
/*Início das implementações de Natalie */
/*Copa*/


/**
 * Salva uma Copa
 * 
 * @author Natalie
 * @param  Cp
 * @throws NegocioException
 * @throws GeralException
 */
public void salvarCopa(Copa cp) throws NegocioException,GeralException {

	if(!rnCopa.existeCopa(cp))
		rnCopa.salvar(cp);
	
	else
		
		throw new GeralException("Copa ja existe");
}

/**
 * Consulta uma Copa pelo Nome
 */

public Copa consultarCopa(Copa cp) throws NegocioException,GeralException{
	
    if(rnCopa.existeCopa(cp))
    return rnCopa.consultar(cp.getNomeCopa());
    
    else
    	
    	throw new GeralException("Consulta: Copa nao existe");
}

public Copa consultarCopaNome(String NomeCopa) throws NegocioException,GeralException{
    	return rnCopa.consultar(NomeCopa);
	}



public Copa consultarCopaId(int codCopa) throws NegocioException,GeralException{
		return rnCopa.consultar(codCopa);
	}

/**
 * Exclui uma Copa pelo Nome
 */

public void excluirCopa(Copa cp) throws NegocioException,GeralException{
	
	if(rnCopa.existeCopa(cp))
		
		rnCopa.excluir(cp.getNomeCopa());
	
	else
		
		throw new GeralException("Copa não existe");
}

public void excluirCopaId(int codCopa) throws NegocioException,GeralException{
	
	if(rnCopa.consultar(codCopa)==null)
		throw new GeralException("Copa não cadastrada!");
        rnCopa.excluir(codCopa);
}

/**
 * Lista todas as Copas
 */

public ArrayList<Copa> listarCopa() throws NegocioException{
	return rnCopa.listarCopa();
}

/* Inicio as implementações da classe SumulaJogo

 * Salva uma Sumula
 * @author Natalie
 * @param  sj
 * @throws NegocioException
 * @throws GeralException
 */
public void salvarSumulaJogo(SumulaJogo sj) throws NegocioException,GeralException {

	if(!rnSumulaJogo.existeSumulaJogo(sj))
		rnSumulaJogo.salvar(sj);
	
	else
		
		throw new GeralException("Sumula ja existe");
}

/**
 * Consulta uma Sumula e verifica se elea existe
 */

public SumulaJogo consultarSumulaJogo(SumulaJogo sj) throws NegocioException,GeralException{
	
    if(rnSumulaJogo.existeSumulaJogo(sj))
    return rnSumulaJogo.consultar(sj.getCodSumula());
    
    else
  	
    	throw new GeralException("Consulta: Sumula nao existe");
}

//Consulta uma Sumula pelo Codigo da Sumula

public SumulaJogo consultarSumulaId(int codSumula) throws NegocioException,GeralException{
		return rnSumulaJogo.consultar(codSumula);
                	
              }

//Consulta uma Sumula pelo Codigo do Jogo

public SumulaJogo consultarJogoId(int codJogo) throws NegocioException,GeralException{
		return rnSumulaJogo.consultar(codJogo);
                	
              }

 //Exclui uma Sumula pelo Codigo da Sumula

public void excluirSumulaId(int codSumula) throws NegocioException,GeralException{
	
	if(rnSumulaJogo.consultar(codSumula)==null)
		throw new GeralException("Sumula não cadastrada!");
        rnSumulaJogo.excluirSumula(codSumula);
}

//Exclui uma Sumula pelo Codigo do jogo

public void excluirJogoId(int codJogo) throws NegocioException,GeralException{
	
	if(rnSumulaJogo.consultar(codJogo)==null)
		throw new GeralException("jogo não cadastrado!");
        rnSumulaJogo.excluirJogo(codJogo);
}
/**
 * Lista todas as sumulas
 */

public ArrayList<SumulaJogo> listar() throws NegocioException{
	
    return rnSumulaJogo.listar();
}

/*Início das implementações da componente Prii */
/*ARBITRO*/

/**
 * Salva um Arbitro
 * 
 * @author Prii
 * @param  arb
 * @throws NegocioException
 * @throws GeralException
 * 
 */

public void salvarArbitro(Arbitro arb) throws NegocioException,GeralException {

	if(!rnArbitro.existeArbitro(arb))
		rnArbitro.salvar(arb);
	else
		throw new GeralException("Arbitro j� cadastrado!");
}


/**
 * Consulta um Arbitro
 * 
 * @author Prii
 * @param arb
 * @return Arbitro
 * @throws NegocioException
 * @throws GeralException
 * 
 */

public Arbitro consultarArbitro(Arbitro arb) throws NegocioException,GeralException{
	
    if(rnArbitro.existeArbitro(arb))
    	return rnArbitro.consultarNome(arb.getNomeArbitro());
    else
    	throw new GeralException("Arbitro n�o cadastrado!");
}


public Arbitro consultarArbitroNome(String nomeArbitro) throws NegocioException,GeralException{
    	return rnArbitro.consultarNome(nomeArbitro);
	}



public Arbitro consultarArbitroCod(int codArbitro) throws NegocioException,GeralException{
		return rnArbitro.consultarCod(codArbitro);
	}

/**
 * Exclui um Arbitro 
 * 
 * @author Prii
 * @param arb
 * @throws NegocioException
 * @throws GeralException
 * 
 */

public void excluirArbitro(Arbitro arb) throws NegocioException,GeralException{
	
	if(rnArbitro.existeArbitro(arb))
		rnArbitro.excluirNome(arb.getNomeArbitro());
	else
		throw new GeralException("Arbitro n�o cadastrado !");
}

public void excluirArbitroCod(int codArbitro) throws NegocioException,GeralException{
	
	if(rnArbitro.consultarCod(codArbitro)==null)
		throw new GeralException("Arbitro n�o cadastrado !");
        rnArbitro.excluirCod(codArbitro);
}

/**
 * Lista todos os Arbitros
 * 
 * @author Prii
 * @return ArrayList<Arbitro>
 * @throws NegocioException
 * 
 */

public ArrayList<Arbitro> listarArbitro() throws NegocioException{
	return rnArbitro.listarArbitro();
}
	
/*Térrmino das implementações da componente PRII*/

}
